{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 逻辑回归\n",
    "逻辑回归就是这样的一个过程：面对一个回归或者分类问题，建立代价函数，然后通过优化方法迭代求解出最优的模型参数，然后测试验证我们这个求解的模型的好坏。\n",
    "\n",
    "Logistic 回归实际上是一种分类方法，主要用于两分类问题（即输出只有两种，分别代表两个类别）\n",
    "\n",
    "回归模型中，y是一个定性变量，比如y=0或1，logistic方法主要应用于研究某些事件发生的概率\n",
    "\n",
    "概念解释\n",
    "\n",
    "### Logistic Regression推导过程\n",
    "\n",
    "它的表达式是:\n",
    "\n",
    "$$f(x) = \\frac{1}{1 + e^{-\\theta}}$$\n",
    "\n",
    "$$\\theta = WX + Bθ=WX+B$$\n",
    "\n",
    "可以发现，经过sigmoid函数转换后, 输出值是在[0, 1]之间，可以认为输出是概率，下面就来详细的推导：\n",
    "\n",
    "\n",
    "为了计算方便, 我们只讨论二分类.\n",
    "\n",
    "首先, 逻辑回归进行了一个假设，两个类别都服从均值不同，方差相同(方便推导)的高斯分布\n",
    "\n",
    "$$p(y|x=0) = \\mu(\\mu_0, \\sigma) $$\n",
    "\n",
    "$$p(y|x=1) = \\mu(\\mu_1, \\sigma)$$\n",
    "\n",
    "高斯分布是比较容易处理的分布，根据中心极限定理也知道，最终会收敛于高斯分布。\n",
    "从信息论的角度上看，当均值和方差已知时（尽管你并不知道确切的均值和方差，但是根据概率论，当样本量足够大时，样本均值和方差以概率1趋向于均值和方差），高斯分布是熵最大的分布，为什么要熵最大？因为最大熵的分布可以平摊你的风险（同一个值会有两个点可以取到, 不确定性很大），这就好比不要把鸡蛋放到同一个篮子里，想想二分查找中，为什么每次都是选取中间点作为查找点？就是为了平摊风险（假设方差相等只是为了计算方便）。\n",
    "\n",
    "风险\n",
    "\n",
    "$$Risk(y=0|x) = \\lambda_{00} $$\n",
    "$$P(y = 1|x)Risk(y=0∣x)=λ00   P(y=0∣x)+λ01 P(y=1∣x)\n",
    "\n",
    "$$Risk(y=1|x) = \\lambda_{10}P(y=0|x) + \\lambda_{11}P(y = 1|x)Risk(y=1∣x)=λ10​P(y=0∣x)+λ11​P(y=1∣x)\n",
    "\n",
    "其中，Risk(y=0|x)Risk(y=0∣x)是把样本预测为0时的风险，Risk(y=1|x)Risk(y=1∣x)是把样本预测为1时的风险，\n",
    "λ_{ij}λij​是样本实际标签为j时，却把它预测为i是所带来的风险。\n",
    "\n",
    "我们认为预测正确并不会带来风险，因此λ_{00}λ00​和λ_{11}λ11​都为0，此外，我们认为当标签为0而预测为1 和 当标签为1而预测为0，这两者所带来的风险是相等的，因此λ_{10}λ10​和λ_{01}λ01​相等，方便起见，我们记为λ。但在一些领域里，比如医学、风控等，这些λ在大多数情况下是不相等的，有时候我们会选择“宁可错杀一一千也不能放过一个”;\n",
    "\n",
    "那么我们简化后的表达式:\n",
    "\n",
    "Risk(y=0|x) = \\lambda P(y = 1|x)Risk(y=0∣x)=λP(y=1∣x)\n",
    "\n",
    "Risk(y=1|x) = \\lambda P(y=0|x)Risk(y=1∣x)=λP(y=0∣x)\n",
    "\n",
    "根据最小化风险的原则，我们通常会选择风险较小的。\n",
    "\n",
    "比如:\n",
    "\n",
    "Risk(y=0|x) &lt; Risk(y=1|x)Risk(y=0∣x)<Risk(y=1∣x)\n",
    "\n",
    "这就说明了预测为第0类的风险小于预测为第1类的风险。\n",
    "\n",
    "可以得到：\n",
    "\n",
    "\\frac{Risk(y=0|x)}{Risk(y=1|x)} &lt; 1Risk(y=1∣x)Risk(y=0∣x)​<1\n",
    "\n",
    "\\frac{P(y = 1|x)}{P(y=0|x)} &lt; 1P(y=0∣x)P(y=1∣x)​<1\n",
    "\n",
    "就是说明预测第1类的概率小于第0类的概率。\n",
    "\n",
    "我们对不等式两边分别取对数\n",
    "\n",
    "log\\frac{{P(y = 1|x)}}{{P(y=0|x)}} &lt; 0logP(y=0∣x)P(y=1∣x)​<0\n",
    "\n",
    "根据贝叶斯公式：\n",
    "\n",
    "log\\frac{P(x|y = 1)p(y=1)}{P(x|y=0)p(y=0)} &lt; 0logP(x∣y=0)p(y=0)P(x∣y=1)p(y=1)​<0\n",
    "\n",
    "log\\frac{P(x|y = 1)}{P(x|y=0)} + log\\frac{p(y=1)}{p(y=0)} &lt; 0logP(x∣y=0)P(x∣y=1)​+logp(y=0)p(y=1)​<0\n",
    "\n",
    "我们开始假设过，两个类别分别服从均值不等，方差相等的高斯分布，根据高斯分布的公式有：\n",
    "\n",
    "高斯分布\n",
    "\n",
    "g(x) = \\frac{1}{2\\pi\\sigma}e^{-\\frac{(x - \\mu)^2}{2\\sigma^2}}g(x)=2πσ1​e−2σ2(x−μ)2​\n",
    "\n",
    "忽略常数项（方差也是相等的）\n",
    "\n",
    "log\\frac{P(x|y = 1)}{P(x|y=0)} + loge^{(\\frac{(x - \\mu_0)^2}{2\\sigma^2} - \\frac{(x - \\mu_1)^2}{2\\sigma^2})}logP(x∣y=0)P(x∣y=1)​+loge(2σ2(x−μ0​)2​−2σ2(x−μ1​)2​)\n",
    "\n",
    "log\\frac{P(x|y = 1)}{P(x|y=0)} + (\\frac{(x - \\mu_0)^2}{2\\sigma^2} - \\frac{(x - \\mu_1)^2}{2\\sigma^2}) &lt; 0logP(x∣y=0)P(x∣y=1)​+(2σ2(x−μ0​)2​−2σ2(x−μ1​)2​)<0\n",
    "\n",
    "log\\frac{P(x|y = 1)}{P(x|y=0)} &lt; \\frac{(x - \\mu_1)^2}{2\\sigma^2} - \\frac{(x - \\mu_0)^2}{2\\sigma^2}logP(x∣y=0)P(x∣y=1)​<2σ2(x−μ1​)2​−2σ2(x−μ0​)2​\n",
    "\n",
    "log\\frac{P(x|y = 1)}{P(x|y=0)} &lt; \\frac{\\mu_0}{\\sigma^2}x - \\frac{\\mu_1}{\\sigma^2}x + ClogP(x∣y=0)P(x∣y=1)​<σ2μ0​​x−σ2μ1​​x+C\n",
    "\n",
    "C是常熟，可以使用矩阵的表示。\n",
    "\n",
    "log\\frac{P(x|y = 1)}{P(x|y=0)} &lt; \\theta{X}logP(x∣y=0)P(x∣y=1)​<θX\n",
    "\n",
    "详细推导\n",
    "\n",
    "对值取幂，以及等式取等号计算。\n",
    "\n",
    "\\frac{P(y=1|x)}{P(y=0|x)} = e^{\\theta x}P(y=0∣x)P(y=1∣x)​=eθx\n",
    "\n",
    "= \\frac{P(y=1|x)}{1 - P(y=1|x)} = e^{\\theta x}=1−P(y=1∣x)P(y=1∣x)​=eθx\n",
    "\n",
    "= \\frac{1 - P(y=1|x)}{P(y=1|x)} = e^{-\\theta x}=P(y=1∣x)1−P(y=1∣x)​=e−θx\n",
    "\n",
    "= \\frac{1}{P(y=1|x)} - 1 = e^{-\\theta x}=P(y=1∣x)1​−1=e−θx\n",
    "\n",
    "= \\frac{1}{P(y=1|x)} = e^{-\\theta x} + 1=P(y=1∣x)1​=e−θx+1\n",
    "\n",
    "= P(y=1|x) = \\frac{1}{e^{-\\theta x} + 1}=P(y=1∣x)=e−θx+11​\n",
    "\n",
    "以下是实现的一些截图"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Logistic Regression表达式\n",
    "\n",
    "$$f(x) = \\frac{1}{1 + e^{-\\theta}}$$\n",
    "\n",
    "$$\\theta = WX + Bθ=WX+B$$\n",
    "\n",
    "#### sigmoid函数的导数\n",
    "\n",
    "$$\\delta{sigmod(x)} = sigmod(x) * (1-sigmod(x))$$\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import tqdm\n",
    "import os"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def sigmoid(x):\n",
    "    return  1 / (1 + np.exp(-x))\n",
    "\n",
    "def delta_sigmoid(x):\n",
    "    return sigmoid(x) * (1 - sigmoid(x))\n",
    "\n",
    "print(sigmoid(-5), sigmoid(5))\n",
    "delta_sigmoid(5)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "np.random.seed(1)\n",
    "features = np.random.randint(1,100, size=(100,2))\n",
    "labels = (features[:,0]  + features[:,1]) // 120\n",
    "print(features.shape, labels.shape)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "print('特征的维度: {0}'.format(features.shape[1]))\n",
    "print('总共有{0}个类别'.format(len(np.unique(labels))))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# 可视化数据\n",
    "figure = plt.figure()\n",
    "plt.scatter([x[0] for x in features], [x[1] for x in features])\n",
    "plt.show()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 基础建模\n",
    "随机初始化权重, 从正态分布中生成"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "W = np.random.uniform(size=(1, features.shape[1]))\n",
    "print('init weight:', W)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# 矩阵乘法\n",
    "def matrix_mul(matrix1, matrix2):\n",
    "    return np.matmul(matrix1, matrix2)\n",
    "print(matrix_mul(np.random.uniform(size=(1, 2)), np.random.uniform(size=(2, 1))))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "矩阵求导\n",
    "\n",
    "$$Result_{ij} = \\sum_{j} W_{i,j} ∗ \\sum_{i} W_{i,j}$$\n",
    "\n",
    "$$δResultijδWij=∑j∈JXj$$\n",
    "\n",
    "$$δW=∑XT∗WeightsT(按权求和)$$"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def delta_matrix(X, W):\n",
    "    return np.matmul(X.T, np.ones(shape=(len(X), 1))).T / len(X)\n",
    "\n",
    "W = np.random.uniform(low=0, high=1, size=(1, 2))\n",
    "X = np.random.uniform(low=3, high=15, size=(3, 2))\n",
    "delta = delta_matrix(X, W)\n",
    "print(delta, W - delta)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# 包含偏置项\n",
    "def add_bias(result, B):\n",
    "#     assert len(result) == len(B)\n",
    "    return result + B\n",
    "\n",
    "B = np.random.uniform(size=(1,))\n",
    "print(B, add_bias(matrix_mul(W, X.T), B))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    " 对偏置项求导\n",
    "\n",
    "yp=WX+B\n",
    "\n",
    "δypB=∑ni1n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def delta_B():\n",
    "    return 1"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "完整的逻辑回归 inference"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def logic(W, X, B):\n",
    "    mul = matrix_mul(W, X)\n",
    "    y = add_bias(mul, B)\n",
    "    return y\n",
    "logic(W, X.T, B)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "损失函数(Cross-entropy, 交叉熵损失函数)\n",
    "信息熵:  −PlogP (P是概率, 小于1, 取反之后就是正数了), 这个值代表的是信息量, 如果值越大代表对当前情况越不确定, 信息不足.\n",
    "\n",
    "$$ loss = −∑y_{t}logyp+(1−yt)log(1−yp)$$\n",
    "\n",
    "yt : 真实的Y值, 需要进行独热编码\n",
    "\n",
    "yp : 预测的Y值"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def loss(Y_t, Y_p):\n",
    "    '''\n",
    "        算交叉熵损失函数\n",
    "        Y_t: 独热编码之后的真实值向量\n",
    "        Y_p: 预测的值向量\n",
    "    '''\n",
    "    trans = np.zeros(shape=Y_t.shape)\n",
    "    for sample_idx in range(len(trans)):\n",
    "        # print(trans[sample_idx], [Y_p[sample_idx], 1.0 - Y_p[sample_idx]])\n",
    "        # 避免出现0\n",
    "        trans[sample_idx] = [Y_p[0][sample_idx] , 1.0 - Y_p[0][sample_idx] + 1e-5]\n",
    "    log_y_p = np.log(trans)\n",
    "    return -np.sum(np.multiply(Y_t, log_y_p))\n",
    "\n",
    "Y_t = np.array([[0, 1], [1, 0]])\n",
    "Y_p = np.array([[0.8, 1]])\n",
    "loss(Y_t=Y_t, Y_p=Y_p)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "交叉熵求导\n",
    "δlossδYp=−δYtlogYpδYp=∑nN−YiPi+1−Yi1−Pi"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def delta_cross_entropy(Y_t, Y_p):\n",
    "    trans = np.zeros(shape=Y_t.shape)\n",
    "    for sample_idx in range(len(trans)):\n",
    "        trans[sample_idx] = [Y_p[0][sample_idx] + 1e-8, 1.0 - Y_p[0][sample_idx] + 1e-8]\n",
    "\n",
    "    Y_t[Y_t == 0] += 1e-8\n",
    "    error = Y_t * (1 / trans)\n",
    "    error[:, 0] = -error[:, 0]\n",
    "    return np.sum(error, axis=1, keepdims=True)\n",
    "\n",
    "Y_t = np.array([[0, 1], [1, 0]], dtype=np.float32)\n",
    "Y_p = np.array([[0.8, 1]])\n",
    "delta_cross_entropy(Y_t=Y_t, Y_p=Y_p)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def accuracy(Y_p, Y_t):\n",
    "    Y_p[Y_p >= 0.5] = 1\n",
    "    Y_p[Y_p < 0.5] = 0\n",
    "    predict = np.sum(Y_p == Y_t)\n",
    "    return predict /  len(Y_t)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "准确率计算\n",
    "混淆矩阵\n",
    "\n",
    "T\\Pre\tPositive\tNegative\n",
    "Positive\tTP\tFN\n",
    "Negative\tFP\tTN\n",
    "评估指标\n",
    "召回率计算\n",
    "\n",
    "recall=TP / TP+FP\n",
    "\n",
    "精准率计算\n",
    "\n",
    "precision=TP / TP+FN"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def recall(Y_p, Y_t):\n",
    "    return np.sum(np.argmax(Y_p) == np.argmax(Y_t)) / np.sum(Y_p == 1)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "独热编码\n",
    "如果有两个类别\n",
    "\n",
    "类别\t独热编码\n",
    "0\t[1, 0]\n",
    "1\t[0, 1]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def one_hot(y):\n",
    "    classes = np.arange(len(np.unique(y)))\n",
    "    one_hot_label = np.zeros(shape=(len(y), len(classes)))\n",
    "    for sample in range(len(y)):\n",
    "        one_hot_label[sample][classes == y[sample]] = 1\n",
    "    return one_hot_label\n",
    "one_hot([0,1,2,3])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "更新权重\n",
    "W=W−φδW=W−δlossδW"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def update_parameters(Y_t, W, B, X, learning_rate=0.1):\n",
    "#     mul = matrix_mul(W, X)\n",
    "#     Y_p = add_bias(mul, B)\n",
    "    Y_p = np.matmul(W, X.T)\n",
    "    Y_p += B\n",
    "    Y_p = sigmoid(Y_p)\n",
    "    error = loss(one_hot(Y_t), Y_p)\n",
    "    # 里面是按列计算的, 进行了转换, 所以这里也需要转置\n",
    "#     delta_loss = delta_cross_entropy(one_hot(Y_t), Y_p)\n",
    "\n",
    "#     delta_activation = delta_sigmoid(Y_p)\n",
    "#     derror = np.multiply(delta_loss, delta_activation)\n",
    "#     dw = np.matmul(derror, X)\n",
    "    # 误差项\n",
    "    error_rate = Y_p - Y_t\n",
    "    deltaW = np.matmul(error_rate, X) / len(Y_t)\n",
    "    deltaB = error_rate * delta_B()\n",
    "    deltaB = np.sum(deltaB) / len(X)\n",
    "    W -= (learning_rate * deltaW)\n",
    "    B -= (learning_rate * deltaB)\n",
    "    return error, W, B"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "W = np.random.uniform(size=(1, 2))\n",
    "print(W)\n",
    "X = np.random.uniform(size=(3, 2))\n",
    "Y_t = np.array([1, 0, 1])\n",
    "update_parameters(Y_t, W, B, X)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "归一化特征数据并且可视化"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "def normalize(x, mean, max_value, min_value, is_normalize=False):\n",
    "    f = copy.deepcopy(x).astype(float)\n",
    "    f -= mean\n",
    "    if is_normalize:\n",
    "        f = (f - min_value) / (max_value - min_value)\n",
    "    return f"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "mean = np.mean(features, axis=0)\n",
    "max_value = np.max(features, axis=0)\n",
    "min_value = np.min(features, axis=0)\n",
    "\n",
    "f_normalize_features = normalize(features, mean, max_value, min_value)\n",
    "print(f_normalize_features)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "figure = plt.figure()\n",
    "plt.scatter([x[0] for x in f_normalize_features[labels == 0]], [x[1] for x in f_normalize_features[labels == 0]], c='r')\n",
    "plt.scatter([x[0] for x in f_normalize_features[labels == 1]], [x[1] for x in f_normalize_features[labels == 1]], c='g')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "mean = np.mean(features, axis=0)\n",
    "max_value = np.max(features, axis=0)\n",
    "min_value = np.min(features, axis=0)\n",
    "\n",
    "f_normalize_features = normalize(features, mean, max_value, min_value, is_normalize=True)\n",
    "\n",
    "figure = plt.figure()\n",
    "plt.scatter([x[0] for x in f_normalize_features[labels == 0]], [x[1] for x in f_normalize_features[labels == 0]], c='r')\n",
    "plt.scatter([x[0] for x in f_normalize_features[labels == 1]], [x[1] for x in f_normalize_features[labels == 1]], c='g')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "拆分数据集\n",
    "分为训练集和测试集, 占比为0.7:0.3"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "test_size = int(len(labels) * 0.3)\n",
    "random_idx = np.random.permutation(len(labels))\n",
    "test_features = features[random_idx[:test_size]]\n",
    "test_labels = labels[random_idx[:test_size]]\n",
    "train_features = features[random_idx[test_size:]]\n",
    "train_labels = labels[random_idx[test_size:]]\n",
    "\n",
    "print('test_features type{0}'.format(test_features.shape))\n",
    "print('train_features type{0}'.format(train_features.shape))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "推理加训练\n",
    "## 学习的曲线"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def drawLine(weights, B=0):\n",
    "    dataArr = features\n",
    "    n = np.shape(dataArr)[0]\n",
    "    xcord1 = []; ycord1 = []\n",
    "    xcord2 = []; ycord2 = []\n",
    "    for i in range(n):\n",
    "        if int(labels[i])== 1:\n",
    "            xcord1.append(dataArr[i,0]); ycord1.append(dataArr[i,1])\n",
    "        else:\n",
    "            xcord2.append(dataArr[i,0]); ycord2.append(dataArr[i,1])\n",
    "    fig = plt.figure()\n",
    "    ax = fig.add_subplot(111)\n",
    "    ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')\n",
    "    ax.scatter(xcord2, ycord2, s=30, c='green')\n",
    "    x = np.arange(0, 100)\n",
    "    y = (B-weights[0][1]*x+1) / weights[0][1]\n",
    "    ax.plot(x, y)\n",
    "    plt.xlabel('X1'); plt.ylabel('X2');\n",
    "    plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "def train(train_features, test_features, train_labels, test_labels, epoch=15, learning_rate=0.008):\n",
    "    W = np.random.uniform(size=(1, train_features.shape[1]))\n",
    "    B = 0\n",
    "    for current in range(epoch):\n",
    "        np.random.seed(current)\n",
    "        random_train_features_idx = np.random.choice(np.arange(len(train_features)), size=(16,))\n",
    "        random_train_features = train_features[random_train_features_idx]\n",
    "        random_train_labels = train_labels[random_train_features_idx]\n",
    "        print('Update W:', W)\n",
    "        Y_p = np.matmul(W, train_features.T)\n",
    "        Y_p += B\n",
    "        Y_p = sigmoid(Y_p)\n",
    "        error = loss(one_hot(train_labels), Y_p) / len(random_train_features)\n",
    "        # 误差项\n",
    "        error_rate = Y_p - train_labels\n",
    "        deltaW = np.matmul(error_rate, train_features) / len(random_train_labels)\n",
    "        deltaB = error_rate * delta_B()\n",
    "        deltaB = np.sum(deltaB) / len(random_train_labels)\n",
    "        W -= (learning_rate * deltaW)\n",
    "        B -= (learning_rate * deltaB)\n",
    "        print('epoch {0}: train_loss:{1}'.format(current + 1, error))\n",
    "        drawLine(W, B)\n",
    "    return W, B"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "train(train_features, test_features, train_labels, test_labels)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## scikit-learn 中的逻辑回归"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "from sklearn import linear_model\n",
    "from sklearn import datasets\n",
    "from sklearn.svm import l1_min_c\n",
    "import time"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "iris = datasets.load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "print(X.shape, y.shape)\n",
    "print(X[:5])\n",
    "\n",
    "X = X[y != 2]\n",
    "y = y[y != 2]\n",
    "X /= X.max()  # Normalize X to speed-up convergence"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "cs = l1_min_c(X, y, loss='log') * np.logspace(0, 7, 16)\n",
    "\n",
    "print(\"Computing regularization path ...\")\n",
    "start = time.time()\n",
    "clf = linear_model.LogisticRegression(penalty='l1', solver='liblinear',tol=1e-6, max_iter=int(1e6), warm_start=True, intercept_scaling=10000.)\n",
    "coefs_ = []\n",
    "for c in cs:\n",
    "    clf.set_params(C=c)\n",
    "    clf.fit(X, y)\n",
    "    coefs_.append(clf.coef_.ravel().copy())\n",
    "print(\"This took %0.3fs\" % (time.time() - start))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "# 预测\n",
    "f = clf.predict(X[:5])\n",
    "print(f)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [
    "coefs_ = np.array(coefs_)\n",
    "plt.plot(np.log10(cs), coefs_, marker='o')\n",
    "ymin, ymax = plt.ylim()\n",
    "plt.xlabel('log(C)')\n",
    "plt.ylabel('Coefficients')\n",
    "plt.title('Logistic Regression Path')\n",
    "plt.axis('tight')\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "training score : 0.995 (multinomial)\n",
      "training score : 0.976 (ovr)\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": "<Figure size 432x288 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 多分类\n",
    "from sklearn.datasets import make_blobs\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# make 3-class dataset for classification\n",
    "centers = [[-5, 0], [0, 1.5], [5, -1]]\n",
    "X, y = make_blobs(n_samples=1000, centers=centers, random_state=40)\n",
    "transformation = [[0.4, 0.2], [-0.4, 1.2]]\n",
    "X = np.dot(X, transformation)\n",
    "\n",
    "for multi_class in ('multinomial', 'ovr'):\n",
    "    clf = LogisticRegression(solver='sag', max_iter=100, random_state=42,\n",
    "                             multi_class=multi_class).fit(X, y)\n",
    "\n",
    "    # print the training scores\n",
    "    print(\"training score : %.3f (%s)\" % (clf.score(X, y), multi_class))\n",
    "\n",
    "    # create a mesh to plot in\n",
    "    h = .02  # step size in the mesh\n",
    "    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n",
    "    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n",
    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
    "                         np.arange(y_min, y_max, h))\n",
    "\n",
    "    # Plot the decision boundary. For that, we will assign a color to each\n",
    "    # point in the mesh [x_min, x_max]x[y_min, y_max].\n",
    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
    "    # Put the result into a color plot\n",
    "    Z = Z.reshape(xx.shape)\n",
    "    plt.figure()\n",
    "    plt.contourf(xx, yy, Z, cmap=plt.cm.Paired)\n",
    "    plt.title(\"Decision surface of LogisticRegression (%s)\" % multi_class)\n",
    "    plt.axis('tight')\n",
    "\n",
    "    # Plot also the training points\n",
    "    colors = \"bry\"\n",
    "    for i, color in zip(clf.classes_, colors):\n",
    "        idx = np.where(y == i)\n",
    "        plt.scatter(X[idx, 0], X[idx, 1], c=color, cmap=plt.cm.Paired,\n",
    "                    edgecolor='black', s=20)\n",
    "\n",
    "    # Plot the three one-against-all classifiers\n",
    "    xmin, xmax = plt.xlim()\n",
    "    ymin, ymax = plt.ylim()\n",
    "    coef = clf.coef_\n",
    "    intercept = clf.intercept_\n",
    "\n",
    "    def plot_hyperplane(c, color):\n",
    "        def line(x0):\n",
    "            return (-(x0 * coef[c, 0]) - intercept[c]) / coef[c, 1]\n",
    "        plt.plot([xmin, xmax], [line(xmin), line(xmax)],\n",
    "                 ls=\"--\", color=color)\n",
    "\n",
    "    for i, color in zip(clf.classes_, colors):\n",
    "        plot_hyperplane(i, color)\n",
    "\n",
    "plt.show()\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Pytorch 中的逻辑回归\n"
   ],
   "metadata": {
    "collapsed": false
   }
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(100, 4) (100,)\n",
      "[[5.1 3.5 1.4 0.2]\n",
      " [4.9 3.  1.4 0.2]\n",
      " [4.7 3.2 1.3 0.2]\n",
      " [4.6 3.1 1.5 0.2]\n",
      " [5.  3.6 1.4 0.2]]\n",
      "[0 0 0 0 0]\n"
     ]
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "iris = datasets.load_iris()\n",
    "X = iris.data\n",
    "y = iris.target\n",
    "X = X[y != 2]\n",
    "y = y[y != 2]\n",
    "\n",
    "print(X.shape, y.shape)\n",
    "print(X[:5])\n",
    "print(y[:5])\n",
    "X /= X.max()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "outputs": [],
   "source": [
    "class LR(nn.Module):\n",
    "    def __init__(self,input_dim, output_dim):\n",
    "        super(LR, self).__init__()\n",
    "        self.linear = nn.Linear(input_dim, output_dim)\n",
    "        self.fc = nn.Sigmoid()\n",
    "    def forward(self,x):\n",
    "        # print(x.shape)\n",
    "        x = self.linear(x) # torch.Size([150, 4])\n",
    "        x = x.squeeze(1) #torch.Size([150])\n",
    "        x = self.fc(x)\n",
    "        return x"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:0, loss:0.6532704830169678\n",
      "acc is 1.0000\n",
      "epoch:50, loss:0.648796021938324\n",
      "acc is 0.9900\n",
      "epoch:100, loss:0.6435272097587585\n",
      "acc is 0.9900\n",
      "epoch:150, loss:0.6384009122848511\n",
      "acc is 0.9900\n",
      "epoch:200, loss:0.6333850622177124\n",
      "acc is 0.9900\n",
      "epoch:250, loss:0.6284577250480652\n",
      "acc is 0.9900\n",
      "epoch:300, loss:0.6236051321029663\n",
      "acc is 0.9900\n",
      "epoch:350, loss:0.6188193559646606\n",
      "acc is 1.0000\n",
      "epoch:400, loss:0.614095151424408\n",
      "acc is 1.0000\n",
      "epoch:450, loss:0.609429121017456\n",
      "acc is 1.0000\n",
      "epoch:500, loss:0.6048191785812378\n",
      "acc is 1.0000\n",
      "epoch:550, loss:0.6002635955810547\n",
      "acc is 1.0000\n",
      "epoch:600, loss:0.5957611203193665\n",
      "acc is 1.0000\n",
      "epoch:650, loss:0.591310977935791\n",
      "acc is 1.0000\n",
      "epoch:700, loss:0.5869120955467224\n",
      "acc is 1.0000\n",
      "epoch:750, loss:0.5825638771057129\n",
      "acc is 1.0000\n",
      "epoch:800, loss:0.5782654285430908\n",
      "acc is 1.0000\n",
      "epoch:850, loss:0.574016273021698\n",
      "acc is 1.0000\n",
      "epoch:900, loss:0.5698155760765076\n",
      "acc is 1.0000\n",
      "epoch:950, loss:0.5656628608703613\n",
      "acc is 1.0000\n"
     ]
    }
   ],
   "source": [
    "net = LR(4, 1)\n",
    "epochs = 1000\n",
    "lr = 0.01\n",
    "criterion = nn.BCELoss()\n",
    "optimizer = torch.optim.SGD(net.parameters(), lr=1e-3, momentum=0.9)\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    inputs = torch.from_numpy(X).float()\n",
    "    labels = torch.from_numpy(y).float()\n",
    "    # print(inputs.dtype, inputs.shape)\n",
    "    optimizer.zero_grad() # 梯度清0\n",
    "    output = net(inputs)\n",
    "    loss = criterion(output,labels)\n",
    "    mask = output.ge(0.5).float()  # 以0.5为阈值进行分类\n",
    "    correct = (mask == labels).sum()  # 计算正确预测的样本个数\n",
    "    acc = correct.item() / inputs.size(0)  # 计算精度\n",
    "\n",
    "    loss.backward() # 反向传播\n",
    "    optimizer.step() # 更新权重 (基于学习率和梯度)\n",
    "    if epoch % 50 == 0:\n",
    "        print(f'epoch:{epoch}, loss:{loss.item()}')\n",
    "        print('acc is {:.4f}'.format(acc))\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.45248547 0.45737845 0.44664967 0.45286703 0.44873196 0.46519756\n",
      " 0.4464212  0.45549268 0.4492243  0.45674422 0.45812082 0.45474118\n",
      " 0.45330924 0.43380594 0.45108348 0.45583043 0.45229498 0.45456648\n",
      " 0.4708711  0.45246956 0.46991792 0.4563241  0.42805108 0.47198784\n",
      " 0.4644211  0.4658268  0.46288922 0.4576938  0.45624435 0.45630142\n",
      " 0.4600654  0.46762934 0.44499037 0.44802698 0.45882845 0.44938016\n",
      " 0.45720974 0.44467664 0.4442458  0.45748028 0.44936427 0.46071023\n",
      " 0.44071767 0.46528742 0.4674626  0.45747414 0.45360816 0.447881\n",
      " 0.45613277 0.45404437 0.625397   0.60989404 0.63321644 0.58840436\n",
      " 0.6216302  0.59931207 0.6144567  0.546372   0.61787546 0.57447696\n",
      " 0.561837   0.5943886  0.59372574 0.61345845 0.56721836 0.6122221\n",
      " 0.59798586 0.5843373  0.6230123  0.5796403  0.61561495 0.5913828\n",
      " 0.63201696 0.61116946 0.60480875 0.61201787 0.63136876 0.6380601\n",
      " 0.60737115 0.565077   0.5762615  0.5710304  0.5821034  0.6310967\n",
      " 0.5941282  0.6008283  0.623407   0.61619496 0.5813504  0.5849363\n",
      " 0.59375024 0.6086713  0.586995   0.5501272  0.58970934 0.5844153\n",
      " 0.5881864  0.60097283 0.54098666 0.5867709 ]\n"
     ]
    }
   ],
   "source": [
    "# 预测\n",
    "test_data = torch.from_numpy(X).float().requires_grad_()\n",
    "pred = net(test_data).data.numpy()\n",
    "print(pred)\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}